/**
 * 异步类使用示例 (zh-promise.js)
 * 此模块提供中文命名的Promise封装，支持异步操作、链式调用、常用工具方法
 */

// 支持 CommonJS 和 ES 模块导入
const promiseModule = require('../../zh/公共函数/zh-promise.js');
const { 异步 } = promiseModule || {
  异步: promiseModule.异步 || promiseModule.default?.异步
};

console.log('=== 异步类 (zh-promise.js) 使用示例 ===\n');

// 1. 基本创建与获取
console.log('1. 基本创建与获取');

// 创建空异步操作（默认成功状态）
const 空异步 = new 异步();
console.log('空异步操作:', 空异步.取值());

// 从值创建异步操作
const 值异步 = new 异步('异步操作的值');
console.log('从值创建的异步:', 值异步.取值());

// 从函数创建异步操作
const 函数异步 = new 异步((resolve, reject) => {
  setTimeout(() => {
    resolve('函数执行的结果');
  }, 100);
});
函数异步.成功(结果 => {
  console.log('函数异步操作结果:', 结果);
});

// 2. 成功回调处理
console.log('\n2. 成功回调处理');

// 静态方法创建成功异步
const 成功异步 = 异步.成功('静态成功结果');
成功异步.成功(result => {
  console.log('静态成功异步结果:', result);
});

// 3. 失败回调处理
console.log('\n3. 失败回调处理');

// 静态方法创建失败异步
const 失败异步 = 异步.失败(new Error('静态失败错误'));
失败异步.失败(error => {
  console.log('静态失败异步错误:', error.message);
});

// 手动失败的异步操作
const 手动失败异步 = new 异步((resolve, reject) => {
  setTimeout(() => {
    reject(new Error('手动触发失败'));
  }, 100);
});
手动失败异步.失败(error => {
  console.log('手动失败异步错误:', error.message);
});

// 4. 总是回调处理
console.log('\n4. 总是回调处理');

// 成功的异步操作的总是回调
异步.成功('测试总是回调')
  .成功(result => console.log('成功结果:', result))
  .总是(() => console.log('成功后总是执行'));

// 失败的异步操作的总是回调
异步.失败(new Error('测试失败的总是回调'))
  .失败(error => console.log('失败错误:', error.message))
  .总是(() => console.log('失败后总是执行'));

// 5. 延迟操作
console.log('\n5. 延迟操作');

// 实例方法延迟
const 延迟异步 = new 异步();
延迟异步.延迟(200).成功(() => {
  console.log('实例方法延迟200ms后执行');
});

// 静态方法延迟
异步.延迟(300, '延迟300ms的值')
  .成功(result => {
    console.log('静态方法延迟结果:', result);
  });

// 6. 链式调用与映射
console.log('\n6. 链式调用与映射');

异步.成功(1)
  .映射(value => value + 1) // 1 -> 2
  .成功(value => {
    console.log('映射后的值:', value);
    return value * 2; // 2 -> 4
  })
  .成功(value => {
    console.log('链式调用后的最终值:', value);
  });

// 7. 错误捕获与恢复
console.log('\n7. 错误捕获与恢复');

异步.失败(new Error('测试错误恢复'))
  .失败(error => {
    console.log('捕获到错误:', error.message);
    return '从错误中恢复';
  })
  .成功(result => {
    console.log('恢复后的值:', result);
  });

// 使用捕获错误方法
异步.失败(new Error('使用捕获错误方法'))
  .捕获错误(error => {
    console.log('使用捕获错误方法捕获:', error.message);
    return '使用捕获错误方法恢复';
  })
  .成功(result => {
    console.log('捕获错误方法恢复后:', result);
  });

// 8. 并行操作
console.log('\n8. 并行操作');

// 创建多个异步操作
const 异步1 = 异步.延迟(100, '异步1结果');
const 异步2 = 异步.延迟(200, '异步2结果');
const 异步3 = 异步.延迟(150, '异步3结果');

// 并行执行所有异步操作
异步.并行([异步1, 异步2, 异步3])
  .成功(results => {
    console.log('并行执行结果数组:', results);
  });

// 9. 任一操作
console.log('\n9. 任一操作');

// 任一执行（取最快完成的）
异步.任一([
  异步.延迟(300, '慢结果'),
  异步.延迟(100, '快结果'),
  异步.延迟(200, '中等结果')
])
  .成功(result => {
    console.log('任一执行结果（最快的）:', result);
  });

// 10. 所有操作状态
console.log('\n10. 所有操作状态');

// 所有操作状态（不管成功失败都返回结果）
异步.所有([
  异步.成功('成功1'),
  异步.失败(new Error('失败1')),
  异步.成功('成功2')
])
  .成功(results => {
    console.log('所有操作状态:');
    results.forEach((result, index) => {
      if (result.status === 'fulfilled') {
        console.log(`  操作${index + 1}: 成功 - ${result.value}`);
      } else {
        console.log(`  操作${index + 1}: 失败 - ${result.reason.message}`);
      }
    });
  });

// 11. 串行执行
console.log('\n11. 串行执行');

// 定义串行执行的异步函数列表
const 异步函数列表 = [
  () => {
    console.log('执行函数1');
    return 异步.延迟(100, 1);
  },
  (value) => {
    console.log(`执行函数2，接收值: ${value}`);
    return 异步.延迟(100, value + 2);
  },
  (value) => {
    console.log(`执行函数3，接收值: ${value}`);
    return 异步.延迟(100, value * 2);
  }
];

// 串行执行
异步.串行(异步函数列表, 0)
  .成功(finalValue => {
    console.log('串行执行最终结果:', finalValue);
  });

// 12. 重试机制
console.log('\n12. 重试机制');

// 定义一个可能失败需要重试的函数
let 尝试次数 = 0;
function 可能失败的操作() {
  尝试次数++;
  console.log(`重试机制 - 尝试次数: ${尝试次数}`);
  if (尝试次数 < 3) {
    // 前两次失败
    throw new Error('操作失败，需要重试');
  } else {
    // 第三次成功
    return '重试后成功';
  }
}

// 使用重试功能
异步.重试(可能失败的操作, 5, 200)
  .成功(result => {
    console.log('重试成功结果:', result);
    console.log('总共尝试次数:', 尝试次数);
  })
  .失败(error => {
    console.log('重试失败:', error.message);
  });

// 13. 超时控制
console.log('\n13. 超时控制');

// 创建一个会超时的操作
const 长时间操作 = new 异步(resolve => {
  setTimeout(() => resolve('操作完成'), 500); // 500ms完成
});

// 添加300ms超时控制
异步.超时(长时间操作, 300)
  .成功(result => {
    console.log('操作在超时前完成:', result);
  })
  .失败(error => {
    console.log('操作超时:', error.message);
  });

// 创建一个不会超时的操作
异步.超时(
  new 异步(resolve => {
    setTimeout(() => resolve('及时完成'), 100); // 100ms完成
  }),
  300,
  new Error('自定义超时错误')
)
  .成功(result => {
    console.log('操作及时完成:', result);
  })
  .失败(error => {
    console.log('这不会执行');
  });

// 14. 同步函数包装
console.log('\n14. 同步函数包装');

// 定义同步函数
function 同步计算(a, b) {
  console.log(`计算 ${a} + ${b}`);
  return a + b;
}

// 包装为异步操作
异步.包装(() => 同步计算(5, 3))
  .成功(result => {
    console.log('同步函数包装结果:', result);
  });

// 15. 等待异步操作
console.log('\n15. 等待异步操作');

// 演示等待方法的使用（在实际async/await环境中使用）
async function 演示等待() {
  try {
    const result = await 异步.延迟(200, '等待成功');
    console.log('异步等待结果:', result);
  } catch (error) {
    console.log('等待过程中出错:', error.message);
  }
}

// 执行演示函数
演示等待();

console.log('\n=== 所有示例启动执行 ===');
// 注意：由于异步操作的特性，实际输出顺序可能与示例顺序不完全一致